
import org.junit.Test;

import java.io.*;

/**
 * @auther yangdong
 * @create 2020-04-13
 * 按数据流的流向不同分为：输入流，输出流
 * 按流的角色的不同分为：节点流，处理流
 * (抽象基类) 字节流 字符流
 * 输入流 InputStream Reader
 * 输出流 OutputStream Writer
 * 1. Java的IO流共涉及40多个类，实际上非常规则，都是从上边4个
 * 抽象基类派生的。
 * 2. 由这四个类派生出来的子类名称都是以其父类名作为子类名后缀。
 *  节点流：直接从数据源或目的地读写数据
 *  处理流：不直接连接到数据源或目的地，而是“连接”在已存
 * 在的流（节点流或处理流）之上，通过对数据的处理为程序提
 * 供更为强大的读写功能。
 */
public class FileReaderWriterTest {
    @Test
    public void testFileReader(){
        File file=new File("src/hello.txt");
        System.out.println(file);
        FileReader fr=null;
        try {
            fr=new FileReader(file);
            int data;
            while((data=fr.read())!=-1){
                System.out.print( (char)data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            if (fr!=null){
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }

    /**
     *  int read()
     * 读取单个字符。作为整数读取的字符，范围在 0 到 65535 之间 (0x00-0xffff)（2个
     * 字节的Unicode码），如果已到达流的末尾，则返回 -1
     *  int read(char[] cbuf)
     * 将字符读入数组。如果已到达流的末尾，则返回 -1。否则返回本次读取的字符数。
     *  int read(char[] cbuf,int off,int len)
     * 将字符读入数组的某一部分。存到数组cbuf中，从off处开始存储，最多读len个字
     * 符。如果已到达流的末尾，则返回 -1。否则返回本次读取的字符数。
     *  public void close() throws IOException
     * 关闭此输入流并释放与该流关联的所有系统资源。
     */
    @Test
    public void testRead(){
        File file=new File("src/hello.txt");
        FileReader fr=null;
        try {
            fr=new FileReader(file);
            char[] c=new char[5];
            int len;
            while((len=fr.read(c))!=-1){
//                for (int i = 0; i <len ; i++) {
//                    System.out.print(c[i]);
//                }
                String string=new String(c,0,len);
                System.out.print(string);

            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            if(fr!=null){
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     *  void write(int c)
     * 写入单个字符。要写入的字符包含在给定整数值的 16 个低位中，16 高位被忽略。 即
     * 写入0 到 65535 之间的Unicode码。
     *  void write(char[] cbuf)
     * 写入字符数组。
     *  void write(char[] cbuf,int off,int len)
     * 写入字符数组的某一部分。从off开始，写入len个字符
     *  void write(String str)
     * 写入字符串。
     *  void write(String str,int off,int len)
     * 写入字符串的某一部分。
     *  void flush()
     * 刷新该流的缓冲，则立即将它们写入预期目标。
     *  public void close() throws IOException
     * 关闭此输出流并释放与该流关联的所有系统资源。
     */
    @Test
    public void testFileWriter(){
        File file=new File("src/hi.txt");
        File file1=new File("src/hello.txt");
        FileWriter fw=null;
        try {
            fw=new FileWriter(file);
            fw.write("hello java \n");
            fw.write("hi java");
            fw.flush();
            fw=new FileWriter(file1,true);
            fw.write("\n hi");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
    @Test
    public void copy(){
        File file =new File("src/hello.txt");
        File file1=new File("src/hello2.txt");
        FileWriter fw=null;
        FileReader fr=null;
        try {
            fw=new FileWriter(file1);
            fr=new FileReader(file);
            char[] c=new char[5];
            int len;
            while ((len=fr.read(c))!=-1){
                fw.write(c,0,len);
                fw.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(fr!=null){
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fw!=null){
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }

}
